(function (modules) {
  // 缓存执行过的模块
  var installedModules = {};

  // 执行模块，执行的时候有引用其他模块会先去执行其他模块
  // 返回加载模块的 exports，给调用的地方使用
  // 缓存执行过的模块
  function __webpack_require__(moduleId) {
    if (installedModules[moduleId]) {
      return installedModules[moduleId].exports;
    }
    var module = (installedModules[moduleId] = {
      i: moduleId,
      l: false,
      exports: {},
    });
    modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
    module.l = true;
    return module.exports;
  }

  // 保存立即执行函数的参数，也就是我们的模块定义
  __webpack_require__.m = modules;

  // 保存 缓存对象
  __webpack_require__.c = installedModules;

  // 判断 对象是否存在 指定的属性
  __webpack_require__.o = function (object, property) {
    return Object.prototype.hasOwnProperty.call(object, property);
  };

  // 给对象添加一个属性 ，并且可以通过 getter 直接访问这个属性
  __webpack_require__.d = function (exports, name, getter) {
    if (!__webpack_require__.o(exports, name)) {
      Object.defineProperty(exports, name, { enumerable: true, get: getter });
    }
  };

  // 给对象身上添加一个标记，通过这个标记可以知道环境是 esModule 还是 非esModule
  __webpack_require__.r = function (exports) {
    // 在 esModule 环境下会成立，给 exports 对象添加一个键
    if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
      //  Object.prototype.toString.call(exports); --> Module
      Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
    }
    // 给 exports 对象添加一个 __esModule 属性，值是 true
    Object.defineProperty(exports, '__esModule', { value: true });
  };

  // create a fake namespace object
  // mode & 1: value is a module id, require it
  // mode & 2: merge all properties of value into the ns
  // mode & 4: return value when already ns object
  // mode & 8|1: behave like require
  __webpack_require__.t = function (value, mode) {
    // 01 调用t方法之后，我们会拿到被加载模块中的内容 value
    // 02 对于 value 来说，我们可以直接返回，也可以处理之后返回
    if (mode & 1) value = __webpack_require__(value);
    if (mode & 8) return value;
    if (mode & 4 && typeof value === 'object' && value && value.__esModule) return value;
    var ns = Object.create(null);
    __webpack_require__.r(ns);
    Object.defineProperty(ns, 'default', { enumerable: true, value: value });
    if (mode & 2 && typeof value != 'string')
      for (var key in value)
        __webpack_require__.d(
          ns,
          key,
          function (key) {
            return value[key];
          }.bind(null, key)
        );
    return ns;
  };

  // 这个就是获取模块默认导出的方法，做了一下  esModule 和 非esModule 环境的兼容
  __webpack_require__.n = function (module) {
    var getter =
      module && module.__esModule
        ? function getDefault() {
            return module['default'];
          }
        : function getModuleExports() {
            return module;
          };
    __webpack_require__.d(getter, 'a', getter);
    return getter;
  };

  // public path
  __webpack_require__.p = '';

  // 在这里开始对第一个(入口)模块定义进行处理

  // __webpack_require__.s 缓存主入口
  return __webpack_require__((__webpack_require__.s = './src/index.js'));
})({
  './src/index.js': function (module, exports, __webpack_require__) {
    let loginTip = __webpack_require__('./src/login.js');
    console.log('index.js内容');
    console.log('loginTip==>', loginTip);
  },
  './src/login.js': function (module, exports) {
    console.log('login.js内容');
    module.exports = '登录成功';
  },
});
